home *** CD-ROM | disk | FTP | other *** search
/ Belgian Amiga Club - ADF Collection / BS1 part 19.zip / BS1 part 19 / Laserdisk.adf / Logo#1 / sim.c < prev    next >
C/C++ Source or Header  |  1987-05-06  |  8KB  |  265 lines
  1. #define TRUE 1
  2. #define FALSE 0
  3. #define MAX 50
  4. #define STRECKE 100
  5.  
  6. #define VOID void
  7. #define nl printf("\n")
  8.  
  9. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  10.  *                                                                     *
  11.  *  Diese Programm simuliert eine moegliche Loesung fuer das           *
  12.  *  Roboter-Problem aus AMIGA-Special Ausgabe Nr.2/88                  *
  13.  *                                                                     *
  14.  *  Erstellt           am 1.2.1988                                     *
  15.  *  Zuletzt  geaendert am --.--.--                                     *
  16.  *                                                                     *
  17.  *  Autor : Manuel Guerrero, 1 Berlin 20, Nordenhamer Str. 18,         *
  18.  *          Tel.:331 67 60                                             *
  19.  *                                                                     *
  20.  *  (C) Copyright 1988 Manuel Guerrero                                 *
  21.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  22.  
  23. /* Funktionen */
  24. int  nimm_max();
  25. int  nimm_min();
  26. int  ueberall_eine();
  27. int  vorher_eine();
  28. VOID bringe_max_weiter();
  29. VOID hole_naechste();
  30. VOID fahre500();
  31.  
  32. /* Batterie: wo und wie voll */
  33. struct Batterietyp {
  34.   int menge;
  35.   int ort;
  36. };
  37.  
  38.  
  39. /* globale Variable                */
  40. struct Batterietyp Batterie[MAX];  /* Batterien            */
  41. int                anz_b;          /* Anzahl der Batterien */
  42. int                punkt;          /* aktueller Standort   */
  43.  
  44.  
  45. void main() {
  46.  /* Vereinbarungen */
  47.   int i;
  48.   int ende;
  49.   int weiter;
  50.  /* Ende Vereinbarungen */
  51.  
  52.   /* Eingabe */
  53.   do {
  54.     printf("Anzahl der Batterien : ");scanf("%d",&anz_b);nl;
  55.   }
  56.   while((anz_b < 1) || (anz_b > MAX));
  57.  
  58.  
  59.   /* Initialisierung */
  60.   punkt = 0;                          /* Wir fangen von vorne an    */
  61.   for(i=0;i<anz_b;i++) {
  62.     Batterie[i].menge = 500;          /* Alle Batterien sind voll   */
  63.     Batterie[i].ort   = 0;            /* ...und liegen am Anfang    */
  64.   }
  65.  
  66.   /* Sonderfaelle abfangen   */
  67.   if(anz_b == 1) fahre500();            /* mit einer kommt man nicht weit */
  68.   else {
  69.     ende = FALSE;                       /* noch sind wir nicht fertig     */
  70.  
  71.     while(ende == FALSE)                /* Bis nichts mehr geht           */
  72.     {
  73.       ende = ueberall_eine();           /* Ende, wenn vor Standpunkt ueber- */
  74.                     /* all nur noch eine Batterie steht */
  75.       if(ende == TRUE) {                /* wenn fertig, Endspurt            */
  76.     /* nimm leerste Batterie, lade dich auf und verschwinde mit der 500er*/
  77.     i=nimm_min();
  78.     printf("nimm Batterie %d\n",Batterie[i].menge);
  79.     printf("lade Akku 100km\n");
  80.     Batterie[i].menge -= STRECKE;     /* Batterie entleeren            */
  81.     printf("lege Batterie weg\n");
  82.     /* nimm die vollste, dann weg                                      */
  83.     i=nimm_max();
  84.     printf("nimm Batterie %d\n",Batterie[i].menge);
  85.     printf("fahre 100km vorwaerts\n");
  86.     Batterie[i].ort++;  /* volle Batterie jetzt eine Punkt weiter        */
  87.     punkt++;            /* 1 Stuetzpunkt weiter mit Energie der alten B. */
  88.  
  89.     fahre500(i);        /* noch 500km mit der vollen Batterie            */
  90.       } /* if ende = TRUE then */
  91.       else {                  /* Wenn noch nicht zuende                      */
  92.     weiter = vorher_eine();/* ist der vorherige Platz noch zu gebrauchen?*/
  93.     if (weiter == TRUE) {    /* Wenn vorher keine verwendbare B. liegt   */
  94.       bringe_max_weiter();   /* mit der leersten aufladen und die ... */
  95.                  /* vollste eins weiter schleppen         */
  96.       } /* if weiter = TRUE then */
  97.       else {                 /* wenn noch brauchbare B. auf Punkt vorher */
  98.         hole_naechste();     /* mit der schwaechsten aufladen und zurueck*/
  99.         bringe_max_weiter(); /* wieder die vollste weiterbringen       */
  100.       } /* if weiter = TRUE else */
  101.       }     /* if ende = TRUE else   */
  102.     } /* while ende = FALSE */
  103.   }   /* if anz_b = 1 else */
  104.  
  105.  
  106.   /* Weite ausrechnen und ausgeben */
  107.   punkt *= STRECKE;
  108.   printf("ich bin %dkm weit gefahren\n",punkt);
  109. } /* main() */
  110. /***** Hauptprogrammende **********************************************/
  111.  
  112.  
  113. /**********************************************************************/
  114. /* vollste Batterie einen Punkt weiter bringen                        */
  115.  
  116. VOID bringe_max_weiter()
  117. {
  118.   int i;
  119.  
  120.   /* mit der schwaechsten Batterie aufladen */
  121.   i = nimm_min();
  122.   printf("nimm Batterie %d\n",Batterie[i].menge);
  123.   printf("lade Akku 100km\n");
  124.   Batterie[i].menge -= STRECKE;
  125.   printf("lege Batterie weg\n");
  126.  
  127.   /* Die staerkste Batterie weiterbringen */
  128.   i = nimm_max();
  129.   printf("nimm Batterie %d\n",Batterie[i].menge);
  130.   printf("fahre 100km vorwaerts\n");
  131.   printf("lege Batterie weg\n");
  132.   Batterie[i].ort++;
  133.   punkt++;
  134. }
  135.  
  136. /**********************************************************************/
  137. /* Batterie vom letzten Punkt holen                                   */
  138.  
  139. VOID hole_naechste()
  140. {
  141.   int i;
  142.  
  143.   /* mit der schwaechsten Batterie aufladen   */
  144.   i = nimm_min();
  145.   printf("nimm Batterie %d\n",Batterie[i].menge);
  146.   printf("lade Akku 100km\n");
  147.   Batterie[i].menge -= STRECKE;
  148.   printf("lege Batterie weg\n");
  149.  
  150.   /* einen Punkt zurueck fahren                */
  151.   printf("fahre 100km zurueck\n");
  152.   punkt--;
  153. }
  154.  
  155. /**********************************************************************/
  156. /* Endebedingung: Ueberall nur noch eine Batterie ?                   */
  157.  
  158. int ueberall_eine()
  159. {
  160.   int i;
  161.   static int anz_auf[200];
  162.  
  163.   /* Sonderfaelle abfangen                               */
  164.   if(punkt == 0) {
  165.     if(anz_b ==2) return(TRUE);
  166.     else return(FALSE);
  167.   }
  168.  
  169.   for(i=0; i<200; i++) anz_auf[i] = 0; /* Initialisieren */
  170.  
  171.   /* Anzahl der B. auf jedem Punkt auszaehlen             */
  172.   for (i = 0; i<anz_b; i++)
  173.     if(Batterie[i].menge > 0) anz_auf[Batterie[i].ort]++;
  174.  
  175.   /* Auswertung                                          */
  176.   for (i = 0; i<punkt; i++)
  177.     if(anz_auf[i] > 1) return(FALSE);
  178.  
  179.  
  180.   if(anz_auf[punkt] == 2) return(TRUE);
  181.     else return(FALSE);
  182. }
  183.  
  184. /**********************************************************************/
  185. /* noch eine brauchbare Batterie auf vorherigem Punkt ?               */
  186.  
  187. int vorher_eine()
  188. {
  189.   int i,mini_b;
  190.   static int anz_auf_vor;
  191.  
  192.   anz_auf_vor = 0;
  193.  
  194.   if(punkt == 0) return(TRUE); /* Sonderfall abfangen */
  195.  
  196.   /* Auszaehlen                                        */
  197.   for (i = 0; i<anz_b; i++)
  198.     if((Batterie[i].menge > 0) && (Batterie[i].ort == (punkt-1)))anz_auf_vor++;
  199.   if (anz_auf_vor > 1) return(FALSE);
  200.  
  201.   mini_b = nimm_min();  /* schwaechste Batterie auf aktueller Position */
  202.   for(i=0;i<anz_b;i++)
  203.     /* wenn auf vorherigem Punkt noch eine brauchbare B. ist...       */
  204.     if((Batterie[i].ort == (punkt-1)) &&
  205.       (Batterie[i].menge > (Batterie[mini_b].menge+100))) return(FALSE);
  206.  
  207.   return(TRUE);
  208. }
  209.  
  210. /**********************************************************************/
  211. /* staerkste Batterie auf aktueller Position                           */
  212.  
  213. int nimm_max()
  214. {
  215.   int max,i;
  216.   int nr = -1;
  217.  
  218.   max = 0;
  219.  
  220.   for (i=0; i<anz_b; i++)
  221.     if ((Batterie[i].ort == punkt) && (Batterie[i].menge > max)){
  222.       max = Batterie[i].menge;
  223.       nr = i;
  224.     }
  225.   return(nr);
  226. }
  227.  
  228. /**********************************************************************/
  229. /* schwaechste Batterie auf aktueller Position                         */
  230.  
  231. int nimm_min()
  232.   {
  233.   int min,i;
  234.   int nr = -1;
  235.  
  236.   min = 501;
  237.  
  238.   for (i=0; i<anz_b; i++)
  239.     if((Batterie[i].ort == punkt)&&(Batterie[i].menge < min)
  240.                  &&(Batterie[i].menge >= 100)) {
  241.       min = Batterie[i].menge;
  242.       nr = i;
  243.     }
  244.   return(nr);
  245.   }
  246.  
  247. /**********************************************************************/
  248. /* Endspurt                                                           */
  249.  
  250. void fahre500(nr)
  251.   int nr;
  252.   {
  253.     int i;
  254.     for (i=1; i<=5; i++) {
  255.       printf("lade Akku 100km\n");
  256.       Batterie[nr].menge -= STRECKE;
  257.       printf("fahre 100km vorwaerts\n");
  258.       Batterie[nr].ort++;
  259.       punkt++;
  260.     }
  261.   }
  262.  
  263. /**********************************************************************/
  264.  
  265.